package com.admin.client.rpc;

import java.util.List;

import com.admin.client.AppConstants;
import com.admin.client.components.GrupoDialog;
import com.admin.client.components.LoginDialog;
import com.admin.client.components.RolesDialog;
import com.admin.client.components.UsuarioDialog;
import com.admin.client.locale.AdminConstants;
import com.admin.share.model.MensajeData;
import com.admin.share.model.PrivilegioDTO;
import com.admin.share.model.RolDTO;
import com.admin.share.model.UsuarioDTO;
import com.admin.share.services.UsuarioServiceAsync;
import com.extjs.gxt.ui.client.Registry;
import com.extjs.gxt.ui.client.data.BaseListLoader;
import com.extjs.gxt.ui.client.data.BaseTreeLoader;
import com.extjs.gxt.ui.client.data.BeanModel;
import com.extjs.gxt.ui.client.data.BeanModelReader;
import com.extjs.gxt.ui.client.data.ListLoadResult;
import com.extjs.gxt.ui.client.data.ListLoader;
import com.extjs.gxt.ui.client.data.LoadEvent;
import com.extjs.gxt.ui.client.data.ModelData;
import com.extjs.gxt.ui.client.data.RpcProxy;
import com.extjs.gxt.ui.client.data.TreeLoader;
import com.extjs.gxt.ui.client.data.TreeModelReader;
import com.extjs.gxt.ui.client.event.LoadListener;
import com.extjs.gxt.ui.client.store.ListStore;
import com.extjs.gxt.ui.client.store.TreeStore;
import com.extjs.gxt.ui.client.widget.MessageBox;
import com.google.gwt.user.client.rpc.AsyncCallback;


public class Usuarios{
	private static UsuarioServiceAsync us = Registry.get(AppConstants.USUARIO_SERVICE);	
	public static TreeLoader<UsuarioDTO> loader;
	public static TreeStore<UsuarioDTO> store;
	public static GrupoDialog grupoDialog;
	public static UsuarioDialog usuarioDialog;
	public static RolesDialog rolesDialog;
	public static String user_id;
	
	public static ListLoader<ListLoadResult<RolDTO>> loaderListView;
	public static ListStore<BeanModel> storeListView;
	public static ListStore<BeanModel> storePrivilegio;
	public static ListLoader<ListLoadResult<ModelData>> loaderPrivilegio;
	
	private static AdminConstants constants = Registry.get(AppConstants.CONSTANTS);

	public static LoginDialog dialog;
	
	public static void list(){
		RpcProxy<UsuarioDTO> proxy = new RpcProxy<UsuarioDTO>() {        
			@Override
	        public void load(Object loadConfig, AsyncCallback<UsuarioDTO> callback) {
	          us.getUsuario((UsuarioDTO) loadConfig,callback);				
	        }
	      };    
	    
	    TreeModelReader<List<UsuarioDTO>> reader = new TreeModelReader<List<UsuarioDTO>>();
	    
	    
	      loader = new BaseTreeLoader<UsuarioDTO>(proxy,reader){
	    	  @Override
	    	  public boolean hasChildren(UsuarioDTO parent) {
	    		  
	    	    return parent.get("haschildren") != null || parent.get("hasusers") != null;
	    	  }
	      };	    
	    
	    store = new TreeStore<UsuarioDTO>(loader);
	   
	}
	
	public static void saveGroup(UsuarioDTO user) {
		user_id = user.getId();
		
		
		us.saveGroup(user, new AsyncCallback<MensajeData>() {

			@Override
			public void onFailure(Throwable caught) {				
				MessageBox.alert(constants.administradorConsultoriaSTI(), constants.errorConexion(), null);	
				store.rejectChanges();
			}

			@Override
			public void onSuccess(MensajeData data) {
				if (data.guardado) {					
					grupoDialog.hide();
					if(user_id != null){
						store.commitChanges();
					}else{						 
						loader.load();
					}
					
				}
				 else {
					 grupoDialog.status.hide();
					 grupoDialog.getButtonBar().enable();	
					 String msg;					
					 if(data.errorTipo == 1)
						 msg = constants.usuarioYaExisteRol();
					 else
						 msg = constants.usuarioNoGuardadoGrupo();
					 MessageBox.alert(constants.administradorConsultoriaSTI(), msg, null);
				}						
			}
			
		});
	}
	
	public static void deleteGroup(String id) {
		  
		  us.deleteGroup(id, new AsyncCallback<MensajeData>() {

				@Override
				public void onFailure(Throwable caught) {					
					MessageBox.alert(constants.administradorConsultoriaSTI(), constants.errorConexion(), null);					
				}

				@Override
				public void onSuccess(MensajeData data) {
					if (data.guardado) {												
						loader.load();						
					}
					 else {						 					 
						 MessageBox.alert(constants.administradorConsultoriaSTI(), constants.usuarioNoEliminadoGrupo(), null);
					}						
				}
				
			});
	}
	
	public static void saveUser(UsuarioDTO user) {
		user_id = user.getId();		
		
		us.saveUser(user, new AsyncCallback<MensajeData>() {

			@Override
			public void onFailure(Throwable caught) {				
				MessageBox.alert(constants.administradorConsultoriaSTI(), constants.errorConexion(), null);	
				store.rejectChanges();
			}

			@Override
			public void onSuccess(MensajeData data) {
				if (data.guardado) {					
					usuarioDialog.hide();
					if(user_id != null){
						store.commitChanges();
					}else{						 
						loader.load();
					}
					
				}
				 else {					 
					 usuarioDialog.status.hide();
					 usuarioDialog.getButtonBar().enable();
					 String msg;
					 if(data.errorTipo == 1)
						 msg = constants.usuarioYaExiste();
					 else
						 msg = constants.usuarioNoGuardadoUsuario();
					 MessageBox.alert(constants.administradorConsultoriaSTI(), msg, null);
				}						
			}
			
		});
	}
	
	public static void deleteUser(String id, String rol_id) {
		  
		  us.deleteUser(id, rol_id, new AsyncCallback<MensajeData>() {

				@Override
				public void onFailure(Throwable caught) {					
					MessageBox.alert(constants.administradorConsultoriaSTI(), constants.errorConexion(), null);					
				}

				@Override
				public void onSuccess(MensajeData data) {
					if (data.guardado) {												
						loader.load();						
					}
					 else {						 					 
						 MessageBox.alert(constants.administradorConsultoriaSTI(), constants.usuarioNoEliminadoUsuario(), null);
					}						
				}
				
			});
	}
	
	public static void listRoles(){
		
		RpcProxy<List<RolDTO>> proxy = new RpcProxy<List<RolDTO>>() {  
		      @Override  
		      protected void load(Object loadConfig, AsyncCallback<List<RolDTO>> callback) { 
		    	  
		    	  us.getRoles(user_id,callback);	  
		      }  
		    };
		    
		    
	     loaderListView = new BaseListLoader<ListLoadResult<RolDTO>>(proxy, new BeanModelReader());  
	     storeListView = new ListStore<BeanModel>(loaderListView);
	     loaderListView.addLoadListener(new LoadListener() {
	    	 
	    	 public void loaderLoad(LoadEvent le) {	    		 
	    		 rolesDialog.setChecked();
	    		 rolesDialog.getButtonBar().enable();
	    	 }
	      });
	}
	
	public static void modificarRoles(List<String> roles_id) {		
		
		
		us.modificarRoles(user_id, roles_id, new AsyncCallback<MensajeData>() {

			@Override
			public void onFailure(Throwable caught) {				
				MessageBox.alert(constants.administradorConsultoriaSTI(), constants.errorConexion(), null);				
			}

			@Override
			public void onSuccess(MensajeData data) {
				rolesDialog.status.hide();
				if (data.guardado) {					
					rolesDialog.hide();											 
					loader.load();					
				}
				 else {					 
					 rolesDialog.getButtonBar().enable();					 
					 MessageBox.alert(constants.administradorConsultoriaSTI(), constants.usuarioNoGuardadoGrupo(), null);
				}						
			}
			
		});
	}
	
	public static void getComboPrivilegios(){
		RpcProxy<List<PrivilegioDTO>> proxy = new RpcProxy<List<PrivilegioDTO>>() {

			@Override
			protected void load(Object loadConfig,AsyncCallback<List<PrivilegioDTO>> callback) {				
				us.getPrivilegios(callback);
			}		      
			
	    };
	    
	    loaderPrivilegio = new BaseListLoader<ListLoadResult<ModelData>>(proxy, new BeanModelReader());
	    
	    storePrivilegio = new ListStore<BeanModel>(loaderPrivilegio);
	}
	
}